export function GetQueryString(name) {
	var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)");
	var r = window.location.search.substr(1).match(reg);
	if (r != null) return unescape(r[2]);
	return null;
}
/* 过滤空对象 */
export function clearDeep(obj) {
	if (!obj || !typeof obj === 'object') return
	const keys = Object.keys(obj)
	for (var key of keys) {
		const val = obj[key]
		if (
			typeof val === 'undefined' ||
			((typeof val === 'object' || typeof val === 'string') && !val)
		) {
			// 如属性值为null或undefined或''，则将该属性删除
			delete obj[key]
		} else if (typeof val === 'object') {
			// 属性值为对象，递归调用
			clearDeep(obj[key])

			if (Object.keys(obj[key]).length === 0) {
				// 如某属性的值为不包含任何属性的独享，则将该属性删除
				delete obj[key]
			}
		}
	}
}
export function downloadObject(record, fileName) {
	// 创建隐藏的可下载链接
	const eleLink = document.createElement('a');
	eleLink.download = `${fileName}-${record.name || new Date().getTime()}.json`;
	eleLink.style.display = 'none';
	// 字符内容转变成blob地址
	const blob = new Blob([JSON.stringify(record)]);
	eleLink.href = URL.createObjectURL(blob);
	// 触发点击
	document.body.appendChild(eleLink);
	eleLink.click();
	// 然后移除
	document.body.removeChild(eleLink);
};
/**
 * @description  返回deptId 是value的部门节点
 * @param {Object} tree 部门数
 * @param {Object} value deptId 的值
 */
export function getOrgbyDept(tree, value) {
	for (var i = 0; i < tree.length; i++) {
		let item = tree[i];
		if (JSON.stringify(item).indexOf('"deptId":' + value) > -1) {
			if (item.deptId == value) {
				return item;
			} else {
				return getOrgbyDept(item.children, value);
			}
			break;
		}
	}
}
// /**
//  *
//  * @param {Object} columns 列
//  * @param {Object} key 查询的key
//  * @param {Object} list optionlist的数据
//  */
// /**
//  * @description 给table的列的筛选条件赋值
//  * @param {Object} columns 列
//  * @param {Object} key 查询的key
//  * @param {Object} value 设置的值
//  * @param {Object} type 设置的类型
//  */
// export function setColumnsSearchInfo(columns, key, value, type) {
// 	let list = JSON.parse(JSON.stringify(columns))
// 	let index = list.findIndex(item => item.key == key);
// 	let item = list[index];
// 	if (item.searchInfo && item.searchInfo.type == 'select') {
// 		item.searchInfo[type] = value
// 	}
// 	this.$set(list, index, item)
// 	return list
// }
// /**
//  * @description 获取table的列的筛选条件值
//  * @param {Object} columns 列
//  * @param {Object} key 查询的key
//  * @param {Object} type 获取的类型
//  */
// export function getColumnsSearchInfo(columns, key, type) {
// 	let list = JSON.parse(JSON.stringify(columns))
// 	let index = list.findIndex(item => item.key == key);
// 	let item = list[index];
// 	if (item.searchInfo) {
// 		return item.searchInfo[type]
// 	}
// 	return undefined
// }



/**
 *
 * @param {Object} columns 列
 * @param {Object} key 查询的key
 * @param {Object} list optionlist的数据
 */
/**
 * @description 给table的列的筛选条件赋值
 * @param {Object} columns 列
 * @param {Object} key 查询的key
 * @param {Object} value 设置的值
 * @param {Object} type 设置的类型
 */
export function setColumnsSearchInfo(columns, key, value, type) {
	let list = JSON.parse(JSON.stringify(columns));
	let index = -1;
	list.forEach((items, indexs) => {
		//当列表key值等于筛选key值 或者(当列表key值不等于筛选key且需要筛选且筛选重写的value值等于筛选key值)
		if (items.key == key || (items.key != key && items.searchInfo && items.searchInfo.value == key)) {
			index = indexs;
		}
	});
	//console.log("index"+index)
	//let index = list.findIndex(item => item.key == key);
	let item = list[index];
	/* console.log("type"+type)
	console.log("item"+JSON.stringify(item))
	console.log("value"+JSON.stringify(value)) */
	if (item && item.searchInfo && ['select', 'rangeText', 'rangeDate', 'treeSelect'].includes(item.searchInfo.type)) {
		item.searchInfo[type] = value;
	}
	this.$set(list, index, item);
	return list;
}
/**
 * @description 获取table的列的筛选条件值
 * @param {Object} columns 列
 * @param {Object} key 查询的key
 * @param {Object} type 获取的类型
 */
export function getColumnsSearchInfo(columns, key, type) {
	let list = JSON.parse(JSON.stringify(columns));
	// let index=-1;
	// list.forEach((items,indexs)=>{
	// 	//当列表key值等于筛选key值 或者(当列表key值不等于筛选key且需要筛选且筛选重写的value值等于筛选key值)
	// 	if(items.key == key||(items.key != key&&items.searchInfo&&items.searchInfo.value==key)){
	// 		index=indexs
	// 	}
	// })
	// console.log("index"+index)
	let index = list.findIndex(item => item.key == key);
	let item = list[index];
	if (item.searchInfo) {
		return item.searchInfo[type];
	}
	return undefined;
}
export function filterOption(input, option) {
	return option.componentOptions.children[0].text.toLowerCase().indexOf(input.toLowerCase()) >= 0;
}
//获取科目名称
export function filterName(value, list) {
	if (value) {
		let index = list.findIndex(item => item.value == value);
		if (index == -1) {
			return '';
		} else {
			return list.find(item => item.value == value).text;
		}

	} else {
		return '';
	}
}
/* 浮点数校正 */
export function toFixed(num) {
	return +parseFloat(Number(num.toFixed(2)).toPrecision(15)) || 0;
}

// 判断字符是否为汉字，
function isChinese(s) {
	return /[\u4e00-\u9fbb|\\！|\\，|\\。|\\（|\\）|\\《|\\》|\\“|\\”|\\？|\\：|\\；|\\【|\\】|\\……|\\￥]/.test(s);
}
// 把字符串中的汉字转换成Unicode
export function ch2Unicdoe(str) {
	if (!str) {
		return;
	}
	var unicode = '';
	for (var i = 0; i < str.length; i++) {
		var temp = str.charAt(i);
		if (isChinese(temp)) {
			unicode += '\\u' + temp.charCodeAt(0).toString(16);
		} else {
			unicode += temp;
		}
	}
	return unicode;
}
export function getBytesLength(str) {
	if (!str) {
		return;
	}
	var num = 0;
	for (var i = 0; i < str.length; i++) {
		var temp = str.charAt(i);
		if (isChinese(temp)) {
			num += 2;
		} else {
			num++
		}
	}
	return num;
}
//简单构造出防抖大致框架
//func 要执行的函数，wait要等待的时间
export function debounce(func, wait, immediate) {
	let timeout, result;

	// 检查func是否为函数
	if (typeof func !== 'function') {
		throw new TypeError('Expected a function');
	}
	// wait如果忘记设置,,默认为0
	wait = wait || 0;
	var debounced = function() {
		// console.log(this);  //=>从中可以测试出this指向的container
		//保存this
		let _this = this;
		// 解决前面的event指向问题
		let args = arguments;
		// 清空上从定时器
		if (timeout) clearTimeout(timeout);
		if (immediate) {
			let callNow = !timeout;
			timeout = setTimeout(() => {
				timeout = null;
			}, wait);
			if (callNow) result = func.apply(_this, args);

		} else {
			timeout = setTimeout(function() {
				// console.log(this)  //=>这里面的this指向window，也就是前面的count那的this是指向window
				//但是防抖函数的this应该是指向container
				func.apply(_this, args);

			}, wait)
		}

		return result;
	}


	//添加取消防抖函数功能
	debounced.cannel = function() {

		clearTimeout(timeout);
		timeout = null;
	}
	return debounced;

}
export function padZero(value) {
	return `000000000${value}`.slice(-10)
}

/**
 * @description  清除输入框中的所有空格
 * @param {Object} e change事件的参数
 */
export function removeAllSpaces(value, type) {
	/* type:0,表示是输入框change事件 */
	if (type == 0) {
		if (value) {
			return value.replace(/\s+/g, "");
		}
	} else {
		return value
	}
}

export function convertToTimestamp(dateString) {
	// 替换秒和毫秒之间的冒号为点  
	const formattedDateString = dateString.replace(/:(\d{3})$/, '.$1');

	// 创建一个Date对象  
	const date = new Date(formattedDateString);

	// 由于Date对象可能不支持毫秒级精度，我们可能需要根据原始字符串手动调整  
	// 但在这个简单的例子中，我们假设环境足够好以支持它  
	// 如果需要，可以在这里添加逻辑来处理不支持毫秒的环境  

	// 获取时间戳  
	return date.getTime();
}

export function priceFormat(number, decimals = 0, decimalPoint = '.', thousandsSeparator = ',') {
	number = (`${number}`).replace(/[^0-9+-Ee.]/g, '')
	const n = !isFinite(+number) ? 0 : +number
	const prec = !isFinite(+decimals) ? 0 : Math.abs(decimals)
	const sep = (typeof thousandsSeparator === 'undefined') ? ',' : thousandsSeparator
	const dec = (typeof decimalPoint === 'undefined') ? '.' : decimalPoint
	let s = ''

	s = (prec ? round(n, prec) + '' : `${Math.round(n)}`).split('.')
	const re = /(-?\d+)(\d{3})/
	while (re.test(s[0])) {
		s[0] = s[0].replace(re, `$1${sep}$2`)
	}

	if ((s[1] || '').length < prec) {
		s[1] = s[1] || ''
		s[1] += new Array(prec - s[1].length + 1).join('0')
	}
	return s.join(dec)
}
export function getRandom(m, n, type) {
	var result = Math.random() * (m - n) + n;
	while (result == n) {
		result = Math.random() * (m - n) + n;
	}
	if (type == 'floor') {
		return parseFloat(result.toFixed(2));
	}
	return Math.round(result);
}
export function calcAge(birthDateObj) {
	// 计算年龄
	const today = new Date();
	birthDateObj = new Date(birthDateObj);
	let age = today.getFullYear() - birthDateObj.getFullYear();
	const monthDiff = today.getMonth() - birthDateObj.getMonth();
	if (monthDiff < 0 || (monthDiff === 0 && today.getDate() < birthDateObj.getDate())) {
		age--;
	}
	return age
}